package org.demo;

import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Pipeline;

public class RedisUtil {
    private static JedisPool jedisPool = null;
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(1024);//连接实例的最大连接数　
            config.setMaxIdle(200);//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
            config.setMaxWaitMillis(10000);//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
            config.setTestOnBorrow(true);// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的
            if(true) {
            	// 无密码
            	jedisPool = new JedisPool(config,
                		"127.0.0.1", //服务器IP地址
                		6379
                		);//数据库模式是16个数据库 0~15 	
            	
            }else {
            	// 有密码
            	jedisPool = new JedisPool(config,
                		"127.0.0.1", //服务器IP地址
                		6379, //端口
                		10000,//连接超时的时间　
                		"123456",//密码
                		0);//数据库模式是16个数据库 0~15 
            }
            

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                System.out.println("redis--服务正在运行: "+resource.ping());
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }
	
    /**
          * 插入
     * @param key
     * @param value
     * @param timeout
     * @return
     */
	public static<T extends Serializable> boolean set(String key,String value,long timeout) {
		getJedis().set(key,
				value,
				"NX",// NX|XX
				"PX",//EX|PX, expire time units: EX = seconds; PX = milliseconds
				timeout);
		return true;
	}
	
	/**
	 * 使用管道批量插入
	 * @param map
	 * @param timeout
	 * @return
	 */
	public static  boolean batchSet(Map<String,String> map,long timeout) {
		Pipeline pipeline = getJedis().pipelined();
		map.forEach((k,v)->{
			pipeline.set(k, v,"NX","PX",(int)timeout);
		});
		pipeline.sync();
		return true;
	}
	
	/**
	 * 获取字符串
	 * @param key
	 * @return
	 */
	public static String get(String key) {
		return getJedis().get(key);
	}
	
	/**
	 * 获取列表
	 * @param key
	 * @return
	 */
	public static List<String> getList(String key) {
		return getJedis().lrange(key, 0, 9999);
	}
	
	/**
	 * keys查询
	 * @param pattern
	 * @return
	 */
	public static Set<String> keys(String pattern) {
		return getJedis().keys(pattern);
	}
}
